// pages/user/bpl-reminder/bpl-reminder.ts
// import { getBPLReminder, setBPLReminder } from '../../../utils/api/BPLControl'
// 注意：后端暂未提供勿扰相关接口，暂时注释

Page({

  /**
   * 页面的初始数据
   */
  data: {
    // 勿扰时段设置
    reminderSettings: {
      enabled: false,
      startTime: '22:00',
      endTime: '06:00'
    },
    showTimePicker: false,
    currentDate: '12:00',
    minHour: 0,
    maxHour: 24,
    timePickerType: '', // 'start' | 'end'
    timePickerTitle: '',
    
    // 🧪 测试模式：不连接后端也能正常使用
    useTestMode: true,  // 改为 false 则尝试连接后端
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad() {
    // 确保初始数据完整
    console.log('页面加载，初始数据:', this.data.reminderSettings);
    
    // 如果初始数据有问题，重新设置
    if (!this.data.reminderSettings || this.data.reminderSettings.enabled === undefined) {
      this.setData({
        reminderSettings: {
          enabled: false,
          startTime: '22:00',
          endTime: '06:00'
        }
      });
      console.log('重新初始化数据');
    }
    
    this.loadReminderSettings()
  },

  /**
   * 加载勿扰时段设置
   */
  async loadReminderSettings() {
    // 🧪 测试模式：使用本地存储
    if (this.data.useTestMode) {
      console.log('🧪 测试模式：加载勿扰设置（本地存储）');
      this.loadLocalSettings();
      return;
    }

    // 正常模式：从服务器加载（待后端接口实现）
    try {
      wx.showLoading({ title: '加载中...' });
      
      // TODO: 等待后端实现 getBPLReminder 接口
      /*
      const res: any = await getBPLReminder();
      
      if (res.code === 200 && res.data) {
        this.setData({
          reminderSettings: {
            enabled: res.data.enabled !== undefined ? res.data.enabled : false,
            startTime: res.data.startTime || '22:00',
            endTime: res.data.endTime || '06:00'
          }
        });
        wx.hideLoading();
        return;
      }
      */
      
      wx.hideLoading();
      console.log('后端接口未实现，使用本地存储');
      this.loadLocalSettings();
      
    } catch (err: any) {
      wx.hideLoading();
      console.log('获取勿扰时段设置失败', err);
      this.loadLocalSettings();
    }
  },

  /**
   * 从本地存储加载设置
   */
  loadLocalSettings() {
    try {
      const localSettings = wx.getStorageSync('bplReminderSettings');
      if (localSettings) {
        // 确保所有字段都有值，避免 undefined
        this.setData({
          reminderSettings: {
            enabled: localSettings.enabled !== undefined ? localSettings.enabled : false,
            startTime: localSettings.startTime || '22:00',
            endTime: localSettings.endTime || '06:00'
          }
        });
        console.log('✅ 加载本地设置成功', this.data.reminderSettings);
      } else {
        // 使用默认值
        this.setData({
          reminderSettings: {
            enabled: false,
            startTime: '22:00',
            endTime: '06:00'
          }
        });
        console.log('✅ 使用默认设置');
      }
    } catch (err: any) {
      console.log('加载本地设置失败', err);
      
      // 使用默认值
      this.setData({
        reminderSettings: {
          enabled: false,
          startTime: '22:00',
          endTime: '06:00'
        }
      });
    }
  },

  /**
   * 时间选择器确认
   */
  onConfirm(event: any) {
    const { detail } = event;
    
    if (this.data.timePickerType === 'start') {
      this.setData({
        'reminderSettings.startTime': detail,
        showTimePicker: false,
        timePickerType: ''
      });
    } else if (this.data.timePickerType === 'end') {
      this.setData({
        'reminderSettings.endTime': detail,
        showTimePicker: false,
        timePickerType: ''
      });
    }
  },

  /**
   * 时间选择器取消
   */
  onCancel() {
    this.setData({
      showTimePicker: false,
      timePickerType: ''
    });
  },

  /**
   * 切换勿扰时段开关
   */
  toggleReminderSwitch(event: any) {
    console.log('收到开关事件:', event);
    
    // 获取开关的值（和血压自动测量一样的逻辑）
    let enabled;
    if (event.detail !== undefined && event.detail !== null) {
      // 如果 detail 有 value 属性
      if (event.detail.value !== undefined) {
        enabled = event.detail.value;
      } 
      // 如果 detail 直接就是布尔值
      else if (typeof event.detail === 'boolean') {
        enabled = event.detail;
      }
      else {
        enabled = false;
      }
    } else {
      enabled = false;
    }
    
    console.log('血压勿扰开关变化:', enabled);
    
    this.setData({
      'reminderSettings.enabled': enabled
    });
  },

  /**
   * 设置开始时间
   */
  setStartTime() {
    this.setData({
      showTimePicker: true,
      timePickerType: 'start',
      timePickerTitle: '选择开始时间',
      currentDate: this.data.reminderSettings.startTime
    });
  },

  /**
   * 设置结束时间
   */
  setEndTime() {
    this.setData({
      showTimePicker: true,
      timePickerType: 'end',
      timePickerTitle: '选择结束时间',
      currentDate: this.data.reminderSettings.endTime
    });
  },

  /**
   * 验证设置
   */
  validateSettings(): boolean {
    const { enabled, startTime, endTime } = this.data.reminderSettings;

    // 如果开启勿扰，需要验证时间
    if (enabled) {
      if (!startTime || !endTime) {
        wx.showToast({
          title: '请设置完整的时间段',
          icon: 'none',
          duration: 2000
        });
        return false;
      }

      // 验证时间格式
      const timeRegex = /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/;
      if (!timeRegex.test(startTime) || !timeRegex.test(endTime)) {
        wx.showToast({
          title: '时间格式不正确',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
    }
    
    // 关闭状态也可以保存（只是不生效）
    return true;
  },

  /**
   * 保存设置
   */
  async saveSettings() {
    if (!this.validateSettings()) {
      return;
    }

    try {
      const settings = this.data.reminderSettings;

      // 🧪 测试模式：只保存到本地
      if (this.data.useTestMode) {
        console.log('🧪 测试模式：保存勿扰设置（本地存储）', settings);
        
        wx.showLoading({ title: '保存中（测试）...' });
        
        // 模拟延迟
        setTimeout(() => {
          wx.setStorageSync('bplReminderSettings', settings);
          wx.hideLoading();
          
          wx.showToast({
            title: '🧪 保存成功',
            icon: 'success',
            duration: 2000
          });

          console.log('🧪 勿扰设置保存成功（本地存储）', settings);

          // 延迟返回上一页
          setTimeout(() => {
            wx.navigateBack();
          }, 1500);
        }, 300);
        
        return;
      }

      // 正常模式：保存到服务器（待后端接口实现）
      wx.showLoading({ title: '保存中...' });

      // 先保存到本地存储
      wx.setStorageSync('bplReminderSettings', settings);

      // TODO: 等待后端实现 setBPLReminder 接口
      /*
      const data = {
        enabled: settings.enabled,
        startTime: settings.startTime,
        endTime: settings.endTime,
        updateTime: new Date().toISOString()
      };
      
      const res: any = await setBPLReminder(data);
      
      if (res.code !== 200) {
        throw new Error(res.message || '保存失败');
      }
      */

      wx.hideLoading();

      wx.showToast({
        title: '保存成功',
        icon: 'success',
        duration: 2000
      });

      console.log('勿扰设置保存成功', settings);

      // 延迟返回上一页
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
      
    } catch (err: any) {
      wx.hideLoading();
      console.log('保存设置失败', err);
      wx.showToast({
        title: '保存失败，请重试',
        icon: 'none',
        duration: 2000
      });
    }
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
  }
})